<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <script>
      //T1
        // var F = function () {};
        // Object.prototype.a = function () {
        //   console.log("a");
        // };
        // Function.prototype.b = function () {
        //   console.log("b");
        // };
        // var f = new F();
        // f.a();//a
        // f.b();//报错
        // F.a();//不执行
        // F.b();//不执行
        /* 
        f.a()
        小f.__proto__===F.prototype
        F.prototype没有a，就去F.prototype.__proto__上面找，也没有
        F.prototype属于对象数据类型
        js内置了构造函数Object，只要是对象都是Oject的实例
        所以F.prototype.__proto__.a === Object.prototype.a
        就是a
        f.b()
        原理同上，因为顶级对象Object的b是undefined，所以调用会报错，后面的代码不执行
        */
        //T2
        // var A = function () {};
        // A.prototype.n = 1;
        // var b = new A();
        // A.prototype = {
        //   n: 2,
        //   m: 3,
        // };
        // var c = new A();
        // console.log(b.n);//1
        // console.log(b.m);//undefined
        // console.log(c.n);//2
        // console.log(c.m);//3
        /* 
        1. b.__proto__ === A.prototype，所以b.n打印出来是1
        2. 因为此时A.prototype没有m，顶级对象里也没有m，所以b.m打印是undefined
        之后进行了
        A.prototype = {
          n: 2,
          m: 3,
        };
        3. c.__proto__ === A.prototype，所以c.n打印出来是2
        4. c.__proto__ === A.prototype，所以c.m打印出来是3
        */

        // //T3
        // var foo = {},
        //   F = function () {};
        // Object.prototype.a = "value a";
        // Function.prototype.b = "value b";
        // console.log(foo.a);//value a 
        // console.log(foo.b);//undefined
        // console.log(F.a);//value a 
        // console.log(F.b);//value b
        /* 
        Object.prototype中添加的内容，所有的数据类型都能使用
        所以foo和F都可以访问到a都是value a 
        Funciton.prototype，所添加的内容，所有函数都能使用
        所以F.b === Function.prototype.b
        foo是对象，里面没有b，Object里面也没有
         */
      //   //T4
        // function A() {}
        // function B(a) {
        //   this.a = a;
        // }
        // function C(a) {
        //   if (a) {
        //     this.a = a;
        //   }
        // }
        // A.prototype.a = 1;
        // B.prototype.a = 1;
        // C.prototype.a = 1;
        // console.log(new A().a);//1
        // console.log(new B().a);//undefined
        // console.log(new C(2).a);//2
        /* 
        第一个new A()创造了一个实例对象
        访问这个实例对象的prototype，就是A.prototype
        A.prototype.a = 1

        第二个function B要输入一个形参，里面的this指向当前实例，this.a是B函数里面的a
        但new B()的时候并没有输入实参，本身函数有a，但没有值赋给this.a，
        所以不会去实例对象的prototype里面找a
        访问new B()的a是没有值，就是undefined

        第三个function C也要输入一个形参
        new C()的时候输入了实参2，进入到if语句判断，this.a指向当前实例的a，a=2
        new C().a就是访问这个实例对象的a，本身函数里面有a=2
        所以不会去实例对象的prototype里面找a
        
        */
    </script>
  </body>
</html>
